|
|
|
 |
Eine Objektvariable verweist auf einen Speicherbereich. Man sagt auch, dass eine Objektvariable ein Objekt referenziert, und spricht bei einer Objektvariablen von einer Objektreferenz oder einfach nur von einer Referenz. Tatsächlich ist unter einer Referenz ein Zeiger auf die Startadresse eines Speicherbereichs zu verstehen, der alle Zustandsdaten – das sind die Eigenschaften, die das Objekt von einem anderen Objekt desselben Typs unterscheidet – beschreibt. Variablen, die auf ein Objekt verweisen, werden auch als Referenztypen bezeichnet. Im Gegensatz dazu kennt .NET auch die Wertetypen wie beispielsweise Int32 (VB-Alias = Integer) oder Int64 (VB-Alias = Long). Bei der Deklaration der Objektvariablen meinKreis wird der für das Objekt erforderliche Speicher reserviert, aber ein konkretes Objekt mit einer Zustandsausprägung durch Eigenschaften existiert schlichtweg noch nicht – die Objektvariable ist noch nicht initialisiert. Zur Initialisierung einer Objektvariablen bieten sich zwei gleichwertige Alternativen an:
Dim meinKreis As Circle meinKreis = New Circle
bzw.Dim meinKreis As Circle = New Circle Dim meinKreis As New Circle Beide weisen ein gemeinsames Merkmal auf: den Operator New, der für die Konkretisierung eines Objekts verantwortlich ist. Erst mit New beginnt der Lebenslauf eines Objekts, denn nun wird eine besondere Methode der Klasse aufgerufen: der Konstruktor; in diesem Fall der parameterlose Standardkonstruktor. Mehr über den Konstruktor erfahren Sie weiter unten in diesem Kapitel.  4.2.2 Zugriffsmodifizierer einer Klasse
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| Modifizierer | Beschreibung |
| Public | Die Instanziierbarkeit einer öffentlichen Klasse unterliegt keinerlei Beschränkungen. Die Klasse kann dann aus jeder beliebigen Anwendung heraus instanziiert werden. |
| Friend | Beabsichtigen Sie, die Sichtbarkeit einer Klasse auf die Anwendung zu beschränken, in der die Klasse definiert ist, müssen Sie die Klasse Friend deklarieren. Aus einer anderen Anwendung heraus kann dann auch kein Objekt dieser Klasse erzeugt werden. |
Die Angabe des Zugriffsmodifizierers ist optional. Verzichten Sie darauf, gilt die Klasse als Friend.
Wir wollen nun die Auswirkungen der beiden Modifizierer Public und Friend an einem praktischen Beispiel erleben. Dabei werden Sie gleichzeitig mit zwei neuen Aspekten der Anwendungsentwicklung unter.NET vertraut gemacht:
 |
mit dem Projekttyp Klassenbibliothek |
| |
mit dem Zugriff auf eine externe Assembly |
Eine Klassenbibliothek wird zu einer DLL-Datei kompiliert und ist somit auch nicht eigenstartfähig. Versuchen Sie dennoch, das Projekt aus der Entwicklungsumgebung heraus zu starten, erhalten Sie eine Fehlermeldung. Sie können jedoch weiterhin über das Menü Erstellen kompilieren.
| Anmerkung |
|
Stellen Sie während der Entwicklungszeit fest, dass Sie sich für den falschen Projekttyp entschieden haben, können Sie diesen im Projekteigenschaftsfenster nachträglich ändern. Doppelklicken Sie dazu den Knoten My Project im Projektmappen-Explorer, und wählen Sie im sich öffnenden Dialog die Einstellung Anwendung. Stellen Sie danach im Listenfeld Anwendungstyp den gewünschten Projekttyp ein. |
Der Code des folgenden Beispiels gehört zu einer Klassenbibliothek und beschreibt die Klassen ClassA, ClassB und ClassC. Klasse ClassA ist Public deklariert und sollte daher auch in anderen Anwendungen sichtbar und folglich instanziierbar sein. Der Zugriffsmodifizierer von ClassB ist Friend. Bisher war es nur möglich, eine Klassendefinition in einer Quellcodedatei zu implementieren, während ClassC auf jeglichen Zugriffsmodifizierer verzichtet.
| ' -------------------------------------------------------------- |
| ' Beispiele: ...\Kapitel 4\LibraryDemo\MyClassLib |
| ' -------------------------------------------------------------- |
| Public Class ClassA |
| Public PropA As Integer = 10 |
| End Class |
| Friend Class ClassB |
| Public PropB As Long = 20 |
| End Class |
| Class ClassC |
| Public str As String = "Hallo" |
| End Class |
Nach dem Kompilieren wird die DLL-Datei im Unterverzeichnis \bin\Debug des Projektverzeichnisses gespeichert.
Eine Klassenbibliothek dient dazu, anderen Anwendungen den Zugriff auf die öffentlichen Typen (= Klassen) zu ermöglichen. Das wollen wir nun durch eine Konsolenanwendung simulieren. Dazu bieten sich zwei Alternativen an:
| |
Sie öffnen ein neues Projekt in der Entwicklungsumgebung. Das erste Projekt (MyClassLib) wird dabei geschlossen. |
| |
Sie fügen der Entwicklungsumgebung ein zweites Projekt hinzu. Das erste Projekt bleibt dabei geöffnet und kann sogar weiter bearbeitet werden. |
Die erstgenannte Methode ist sehr einfach, daher wollen wir uns der zweiten zuwenden, bei der wir zudem tiefer gehende Kenntnisse zur Entwicklung komplexerer Anwendungen mit dem Visual Studio erlangen.
Bisher haben wir in der Entwicklungsumgebung immer nur mit einem Projekt gearbeitet. Das Visual Studio ermöglicht aber auch, mehrere Projekte gleichzeitig parallel zu bearbeiten. Verwaltet werden die einzelnen Projekte in einer Projektmappe, die damit die Aufgabe eines Containers innehat. Das Visual Studio generiert beim Erstellen eines neuen Projekts eine Projektmappe, die anschließend um praktisch beliebig viele, auch unterschiedliche Projekttypen erweitert werden kann. Damit erübrigt sich das mehrfache Öffnen des Visual Studios, wenn an mehreren Projekten gearbeitet werden soll. Die von einer Projektmappe verwalteten Projekte können, müssen aber nicht zwangsläufig in einem logischen Zusammenhang stehen.
Auch Projektmappen haben einen Bezeichner. Dieser wird vergeben, sobald Sie die Entwicklungsumgebung starten und ein neues Projekt erstellen. Der Standardbezeichner einer Projektmappe ist der des ersten Projekts, sollte allerdings insbesondere dann einen spezifischen Namen bekommen, wenn Sie wissen, dass Sie im Laufe der Entwicklungstätigkeit mindestens noch ein weiteres Projekt hinzufügen wollen. Im Dialog Neues Projekt können Sie die entsprechenden Einstellungen vornehmen. In Abbildung 4.5 ist zu erkennen, dass die Wahl auf ein Projekt des Typs Klassenbibliothek gefallen ist, der Bezeichner des Projekts lautet MyClassLib und der der Projektmappe LibraryDemo.
Hier klicken, um das Bild zu Vergrößern
Abbildung 4.5 Anlegen einer Projektmappe
Um die Entwicklungsumgebung um ein weiteres Projekt zu ergänzen, müssen Sie im Projektmappen-Explorer den Knoten der Projektmappe markieren, dessen Kontextmenü öffnen und Hinzufügen Neues Projekt... auswählen. Zur Auswahl stehen alle möglichen Projekttypen. Wir wollen unsere oben begonnene Klassenbibliothek testen, deshalb fällt die Wahl auf die Konsolenanwendung. Der Name des neuen Projekts sei LibraryTest.
Werfen wir nun einen Blick in den Projektmappen-Explorer. Das zweite Projekt ist jetzt ebenfalls eingetragen. Werden von einer Projektmappe mehrere Projekte verwaltet, kann nur eins davon beim Klicken der Schaltfläche Starten in der Symbolleiste des Visual Studios ausgeführt werden. Es ist immer das, dessen Projektbezeichner fett geschrieben ist. In der Abbildung 4.6 würde es sich demnach um das Projekt MyClassLib, also die Klassenbibliothek handeln. Die Einstellung ist nicht korrekt. Um ein anderes Projekt zum Startprojekt zu erklären, müssen Sie das Kontextmenü des entsprechenden Projekts öffnen und Als Startprojekt festlegen auswählen.
Hier klicken, um das Bild zu Vergrößern
Abbildung 4.6 Projektmappen-Explorer, der zwei Projekte beherbergt
Physikalisch werden beide Projekte MyClassLib und LibraryTest als Unterordner der Projektmappe LibraryDemo gespeichert. In Letzterer ist eine Datei mit den Dateierweiterung .SLN zu finden, in der die Daten enthalten sind, welche die Projektmappe definieren.
Das Projekt LibraryTest soll dazu dienen, die Klassenbibliothek MyClassLib zu testen. Allerdings ist LibraryTest die Existenz von MyClassLib nicht bekannt, wir müssen die Klassenbibliothek zunächst bekannt geben. Dazu dient der Knoten Verweise im Projektmappen-Explorer, den Sie jedoch erst zu Gesicht bekommen, wenn Sie vorher in der Symbolleiste des Projektmappen-Explorers die Schaltfläche Alle Dateien anzeigen angeklickt haben.
Im Kontextmenü des Knotens Verweise wählen Sie Verweis hinzufügen... Daraufhin öffnet sich der in Abbildung 4.7 gezeigte Dialog mit den Registerkarten .NET, COM, Projekte, Durchsuchen und Aktuell. Am einfachsten ist es, Projekte auszuwählen, da in dieser Registerkarte die Projekte der aktuellen Projektmappe aufgeführt sind.
Hier klicken, um das Bild zu Vergrößern
Abbildung 4.7 Der Dialog »Verweis hinzufügen«
Damit sind der Testanwendung alle notwendigen Informationen bekannt, und es kann der folgende Code geschrieben werden:
| ' -------------------------------------------------------------- |
| ' Beispiele: ...\Kapitel 4\LibraryDemo\LibraryTest |
| ' -------------------------------------------------------------- |
| Module Module1 |
| Sub Main() |
| ' Instanziierung der Klasse ClassA |
| Dim obj As MyClassLib.ClassA = New MyClassLib.ClassA |
| ' dem Feld 'PropA' einen neuen Wert zuweisen |
| obj.PropA = 4711 |
| ' Ausgabe des Feldes an der Konsole |
| Console.WriteLine(obj.PropA) |
| Console.ReadLine() |
| End Sub |
| End Module |
In Main wird ein Objekt vom Typ ClassA erzeugt. ClassA ist innerhalb des Namespaces MyClassLib definiert. Namespaces dienen dazu, die Eindeutigkeit von Klassennamen zu gewährleisten. Um auf eine Klasse zuzugreifen, muss vor dem Klassenbezeichner der Namespace angegeben werden. Beide werden durch einen Punkt voneinander getrennt.
| Dim obj As MyClassLib.ClassA = New MyClassLib.ClassA() |
| Imports MyClassLib |
den Namensbereich der Komponente vorher bekannt gegeben, hätte die Anweisung deutlich kürzer ausfallen können:
| Dim obj As ClassA = New ClassA |
Zu dem Thema dieses Abschnitts, der Entwicklung einer Klassenbibliothek, sind wir gelangt, weil wir uns von der Wirkungsweise der Zugriffsmodifizierer überzeugen wollten. Wir sehen die Aussagen bestätigt, wenn wir die Liste der Intellisense-Unterstützung hinter der Namespace-Angabe MyClassLib beobachten. Hier wird nur ClassA aufgeführt, jedoch weder die mit Friend deklarierte ClassB noch ClassC, der wir explizit keinen Zugriffsmodifizierer zugestanden haben (siehe Abbildung 4.8).
Hier klicken, um das Bild zu Vergrößern
Abbildung 4.8 Intellisense-Unterstützung beim Zugriff auf eine externe Komponente
Wie oben erwähnt, darf jede Quellcodedatei mehrere Klassendefinitionen enthalten. Der Projektmappen-Explorer als Tool zur Verwaltung der projektbezogenen Dateien ist nicht in der Lage, die in einer Datei enthaltenen Klassendefinitionen anzuzeigen. Diese Aufgabe übernimmt die Klassenansicht, die darüber hinaus in einer hierarchischen Struktur alle Klassenmitglieder auflistet.
Die Klassenansicht ist in zwei Teilbereiche gegliedert. Im oberen sind die Typdefinitionen aufgeführt, zu denen nicht nur eine Klasse, sondern beispielsweise auch Strukturen, Enumerationen, Schnittstellen usw. gerechnet werden. Detailinformationen zu einer markierten Typdefinition werden im unteren Teilbereich angezeigt. In Abbildung 4.9 ist das Modul der Konsolenanwendung ausgewählt. Dieses enthält nur die Methode Main.
Hier klicken, um das Bild zu Vergrößern
Abbildung 4.9 Die »Klassenansicht« der Beispielanwendung »LibraryTest«
Bisher war es nur möglich, eine Klassendefinition in eine Quellcodedatei zu implementieren. Mit der Einführung des .NET Frameworks 2.0 wird dem Entwickler die Möglichkeit geboten, eine Klassendefinition auf beliebig viele Sourcecode-Dateien aufzuteilen. Die neue Programmiertechnik gestattet es unter anderem, bei großen Klassendefinitionen die Übersicht zu gewährleisten.
Partielle Klassendefinitionen werden durch die Ergänzung des Modifizierers Partial gekennzeichnet. Bei einer partiellen Definition dürfen Sie auf Partial verzichten, müssen es aber nicht. Diese Klasse ist dann gewissermaßen die Ausgangsklasse.
Nehmen wir beispielsweise an, Sie möchten die Klasse ClassA auf die beiden Dateien ClassA1.vb und ClassA2.vb aufteilen. Dann können die Klassendefinitionen wie folgt lauten:
| ' In der Quellcodedatei 'ClassA1.cs' |
| ' optional kann hier ebenfalls 'Partial' angegeben werden |
| Public Class ClassA |
| ' Klassendefinition |
| End Class |
| ' In der Quellcodedatei 'ClassA2.cs' |
| Partial Public Class ClassA |
| ' Klassendefinition |
| End Class |
Das Aufteilen von Typdefinitionen beschränkt sich nicht nur auf Klassen. Auch auf Strukturen und Interfaces kann Partial angewandt werden. Eine Einschränkung des Gebrauchs partieller Typen müssen Sie jedoch beachten: Alle Klassenfragmente müssen sich in derselben Anwendung, also derselben EXE- oder DLL-Datei und im gleichen Namespace, befinden.
| |
Eine Klasse ist die Bauanleitung für Objekte eines bestimmten Typs. Ein Objekt wird durch Eigenschaften und Methoden beschrieben. |
| |
Die Sichtbarkeit einer Klasse wird durch Public und Friend beschrieben. Fehlt die Angabe eines Zugriffsmodifizierers, gilt die Klasse als mit Friend deklariert und ist nur im aktuellen Projekt bekannt. |
| |
Objektvariablen werden mit dem Schlüsselwort New initialisiert und haben danach einen definierten Zustand. Bei der Instanziierung mit New wird eine Erstellungsroutine aufgerufen, die als Konstruktor bezeichnet wird. |
| |
Klassen-, Struktur- und Interface-Definitionen können sich über mehrere Quellcodedateien verteilen. Das Schlüsselwort Partial führt bei der Kompilierung die gesplittete Klassendefinition zusammen. |
| << zurück |
|
||||||||||||||
 |
||||||||||||||
|
||||||||||||||
|
||||||||||||||
|
||||||||||||||
|
||||||||||||||
|
||||||||||||||
Copyright © Galileo Press 2007
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken.
Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die
gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich
geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung,
Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.
